package br.unisinos.tga;

import com.sun.opengl.util.Animator;
import com.sun.opengl.util.GLUT;
import java.awt.Frame;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.IntBuffer;
import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileFilter;
import javax.swing.filechooser.FileNameExtensionFilter;

/**
 * Editor de cenário Isométrico.
 *
 * Processamento gráfico, 23. Autor: Douglas Brauner e Pedro Guilherme Rohr.
 * 2013.
 */
public class EditorIsometrico extends JFrame implements GLEventListener, MouseListener, KeyListener, MouseMotionListener {

    private GLUT glut = new GLUT();
    private static int mousex;
    private static int mousey;
    private static boolean clicou = false;
    private Menu menu = new Menu();
    private Cenario cenario = new Cenario();
    int windowW = 1024;
    int windowH = 768;
    private static final int MAX_TILE_DIAMOND = 15;
    private static Imagem imagemDefault;
    private static int tileId = 0;
    private static boolean deletarTile = false;
    private static boolean mouseReleased = false;
    private static boolean mousePressed = false;
    private static boolean desenhaDragAndDrop = false;

    /** Variáveis utilizadas para o efeito DragAndDrop do tile */
    private static int xTileDragAndDrop = 0;
    private static int yTileDragAndDrop = 0;
    private Imagem imagemDragAndDrop = null;
    /** Variáveis utilizadas para capturar movimento de teclado */
    private static boolean pressedTecDown = false;
    private static boolean releasedTecDown = false;
    private static boolean pressedTecUp = false;
    private static boolean releasedTecUp = false;
    private static boolean pressedTecLeft = false;
    private static boolean releasedTecLeft = false;
    private static boolean pressedTecRight = false;
    private static boolean releasedTecRight = false;

    public static void main(String[] args) {
        Frame frame = new Frame("Editor");
        GLCanvas canvas = new GLCanvas();

        canvas.addGLEventListener(new EditorIsometrico());
        //    canvas.addMouseListener(this);
        frame.add(canvas);
        frame.setSize(1024, 768);
        final Animator animator = new Animator(canvas);
//        frame.setResizable(false);
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                // Run this on another thread than the AWT event queue to
                // make sure the call to Animator.stop() completes before
                // exiting
                new Thread(new Runnable() {
                    public void run() {
                        animator.stop();
                        System.exit(0);
                    }
                }).start();
            }
        });
        // Center frame
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        animator.start();
    }

    public void init(GLAutoDrawable drawable) {
        drawable.addMouseListener(this);
        drawable.addKeyListener(this);
        drawable.addMouseMotionListener(this);

        GL gl = drawable.getGL();

        // Enable VSync
        gl.setSwapInterval(1);

        // Setup the drawing area and shading mode
        gl.glClearColor(0.9f, 0.9f, 0.9f, 1.0f); // Fundo preto
        gl.glShadeModel(GL.GL_FLAT); // try setting this to GL_FLAT and see what happens.

        int[] viewport = {0, 0, 0, 0};
        // Pega o tamanho atual da tela
        gl.glGetIntegerv(GL.GL_VIEWPORT, viewport, 0);
        windowH = viewport[3];

        gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1);
        /* INicializa dados da imagem */
        cenario.setIsoView(new IsometricView(cenario.getAltura(), cenario.getLargura()));
        cenario.setTileSet(new Tileset());

        /* Carrega o tile padrão que não está no Tileset */
        menu.carregaMenu();
        File file = new File("default.ppm");
        InputStream is = null;
        try {
            is = new FileInputStream(file);
        } catch (FileNotFoundException ex) {
            System.out.println("Erro");
        }
        PPM ppm = new PPM();
        try {
            ppm.loadPPM(is);
        } catch (IOException ex) {
            System.out.println("Erro");
        }
        imagemDefault = ppm.getImagem();
        imagemDefault.setPixels((IntBuffer) imagemDefault.getPixels().rewind());

    }

    public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
        GL gl = drawable.getGL();
        GLU glu = new GLU();

        if (height <= 0) { // avoid a divide by zero error!

            height = 1;
        }
        gl.glViewport(0, 0, width, height);

        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        glu.gluOrtho2D(0.0, (double) width, 0.0, (double) height);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();
    }

    public void display(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();

        // Clear the drawing area
        gl.glClear(GL.GL_COLOR_BUFFER_BIT);
        // Reset the current matrix to the "identity"
        gl.glLoadIdentity();

        //Muda a cor para branco
        gl.glColor3f(1.0f, 1.0f, 1.0f);

        /* Verifica se soltou o clique do mouse para tratar eventos */
        if (mouseReleased) {
            // Se clicou na barra de menu 
            switch (menu.verificaMenu(mousex, mousey)) {
                case Menu.NOVO:
                    novo();
                    break;
                case Menu.ADDFILE:
                    addTileSet();
                    break;
                case Menu.SALVAR:
                    salvar();
                    break;
                case Menu.ABRIR:
                    carregar();
                    break;
                case Menu.ADD_GUY:
                    adicionaBoneco();
                case Menu.DELETAR:
                    deletarTile = true;
                    break;
                default:
                    break;
            }
            // Se estava arrastando um tile para o mapa
            if (desenhaDragAndDrop) {
                verificaCliqueTileMap();
                desenhaDragAndDrop = false;
            }
            mouseReleased = false;
        }

        // Se o mouse está pressionado
        if (mousePressed) {
            int id = verificaCliqueTileSet(gl);
            if (id != 0) {
                // Desenha imagem do efeito DragAndDrop na posição do mouse
                criaImagemDragAndDrop(id);
                desenhaDragAndDrop = true;
            } else {
                 verificaCliqueTileMap();
            }
            mousePressed = false;
        }

        verificaMovimentoPersonagem();
        // Desenha o menu da janela
        menu.exibeMenu(gl);
        // Desenha a imagem de mapa de tiles
        exibeDiamondMap(gl);

        // Exibe o tileset no rodapé
        exibeTileSet(gl);
        // Se deve desenhar o tile sob o mouse
        if (desenhaDragAndDrop) {
            desenhaTileDragAndDrop(gl);

        }
        // Move the "drawing cursor" around
        //      gl.glRasterPos2i(0, 500 - imagem.getAltura());
        // Flush all drawing operations to the graphics card
        gl.glFlush();

    }


    /**
     * Atualiza clique do mouse
     * @param e 
     */
    public void mouseClicked(MouseEvent e) {

        switch (e.getButton()) {
            case MouseEvent.BUTTON1:
                mousey = e.getY();
                mousex = e.getX();

                clicou = true;
                break;
            default:
                break;
        }
    }

    /**
     * Realiza um ajuste no tile identificado como clicado. Se clicou em 
     * uma área trasparente da imagem, direciona para o tile naquela direção.
     * Se clicou fora das dimensões, igonora. 
     * @param x
     * @param y 
     */
    private void ajustaPosicao(int x, int y) {
        int xTile = x - cenario.getIsoView().x;
        int yTile = y - cenario.getIsoView().y;
        int linha = cenario.getIsoView().linha;
        int coluna = cenario.getIsoView().coluna;
        int tileId = cenario.getIsoView().tileMap.getTileId(linha, coluna);
        int rgb;

        if (xTile > 64 || yTile > 32 || xTile < 0 || yTile < 0) {
            return;
        }

//        System.out.println("x:" + xTile + " y " + yTile);
        if (tileId == 0) {
            rgb = imagemDefault.getARGB(xTile, yTile);
        } else {
            Tile t1 = cenario.getTileSet().getTile(tileId);
            rgb = t1.getImagem().getARGB(xTile, yTile);
        }

        if (rgb == Imagem.TRANSPARENTE) {

            if (xTile > 32) {
                if (yTile > 16) {
                    cenario.getIsoView().tileWalking(TileMapViewInterface.NORDESTE);
                } else {
                    cenario.getIsoView().tileWalking(TileMapViewInterface.SUDESTE);
                }
            } else {
                if (yTile > 16) {
                    cenario.getIsoView().tileWalking(TileMapViewInterface.NOROESTE);
                } else {
                    cenario.getIsoView().tileWalking(TileMapViewInterface.SUDOESTE);
                }
            }
        }
    }

    /**
     * Atualiza o clique do mouse
     * @param e 
     */
    public void mousePressed(MouseEvent e) {

        int menuClique = menu.verificaMenu(e.getX(), getY());
        if (menuClique != 0) {
            menu.aplicaTransparencia(menuClique);
        }
        switch (e.getButton()) {
            case MouseEvent.BUTTON1:
                mousey = e.getY();
                mousex = e.getX();
                break;
            default:
                break;
        }
        mousePressed = true;


    }

    /**
     * Atualiza o soltar do mouse
     * @param e 
     */
    public void mouseReleased(MouseEvent e) {
        menu.removeTransparencia();
        switch (e.getButton()) {
            case MouseEvent.BUTTON1:
                mousey = e.getY();
                mousex = e.getX();
                mouseReleased = true;
                break;
            default:
                break;
        }

    }

    public void mouseEntered(MouseEvent e) {
    }

    public void mouseExited(MouseEvent e) {
    }

    /**
     * Avalia qual tecla soltou
     * @param e 
     */
    public void keyReleased(KeyEvent e) {

        switch (e.getKeyCode()) {
            case KeyEvent.VK_DOWN:
                releasedTecDown = true;
                break;
            case KeyEvent.VK_UP:
                releasedTecUp = true;
                break;
            case KeyEvent.VK_LEFT:
                releasedTecLeft = true;
                break;
            case KeyEvent.VK_RIGHT:
                releasedTecRight = true;
                break;
            default:
                break;
        }
    }

    public void keyTyped(KeyEvent e) {
    }

    /**
     * Avalia qual tecla pressionou
     * @param e 
     */
    public void keyPressed(KeyEvent e) {

        switch (e.getKeyCode()) {
            case KeyEvent.VK_DOWN:
                pressedTecDown = true;
                break;
            case KeyEvent.VK_UP:
                pressedTecUp = true;
                break;
            case KeyEvent.VK_LEFT:
                pressedTecLeft = true;
                break;
            case KeyEvent.VK_RIGHT:
                pressedTecRight = true;
                break;
            default:
                break;
        }
    }

    /**
     * Cria um novo cenário, permitindo informar as dimensões em tamanho de tiles
     * para largura e altura.
     */
    private void novo() {
        int largura;
        int altura;
        while (true) {

            largura = Integer.parseInt(JOptionPane.showInputDialog(null, "Informe a lagura do cenário", "novo", JOptionPane.INFORMATION_MESSAGE));
            if (largura > 15) {
                JOptionPane.showMessageDialog(null, "Por favor, escolha um tamanho de no máximo 15.");
            } else {
                altura = Integer.parseInt(JOptionPane.showInputDialog(null, "Informe a altura do cenário", "novo", JOptionPane.INFORMATION_MESSAGE));
                if (altura > 15) {
                    JOptionPane.showMessageDialog(null, "Por favor, escolha um tamanho de no máximo 15.");
                } else {
                    break;
                }
            }
        }
        cenario.setAltura(altura);
        cenario.setlargura(largura);
        cenario.setLarguraImagem((largura * 32) + (altura * 32));
        cenario.setAlturaImagem((largura * 18) + (altura * 18));
        cenario.setIsoView(new IsometricView(largura, altura));
        cenario.setTileSet(new Tileset());
    }

    /**
     * Abre janela para selecionar um arquivo para carregar como cenário, limitando
     * às extensões .isom.
     */
    private void carregar() {
        FileFilter filter = new FileNameExtensionFilter("Cenário Isométrico", "isom");
        JFileChooser fc = new JFileChooser();
        fc.setFileFilter(filter);
        int option = fc.showOpenDialog(null);
        if (option == JFileChooser.APPROVE_OPTION) {
            File f = fc.getSelectedFile();
            String filePath = f.getPath();
            if (!f.getName().contains(".isom")) {
                JOptionPane.showMessageDialog(null, "Esta não é uma extensão válida para cenário isométrico!");
                return;
            }
            cenario.carregarCenario(f);
        }
    }

    /**
     * Permite escolher nome do arquivo a salvar e definir o diretório onde será salvo.
     * Já chama rotina para efetuar a gravação do arquivo.
     */
    private void salvar() {
        int opcao;
        if (cenario.getNome() == null || cenario.getNome().equals("")) {
            String nome = JOptionPane.showInputDialog(null, "Informe o nome de seu cenário", "Nome", JOptionPane.INFORMATION_MESSAGE);
            if (nome != null) {
                cenario.setNome(nome);
            } else {
                return;
            }
        } else {
            opcao = JOptionPane.showConfirmDialog(null, "Deseja manter o nome '" + cenario.getNome() + "' para seu cenário?");
            if (opcao == JOptionPane.NO_OPTION) {
                String nome = JOptionPane.showInputDialog(null, "Informe o nome de seu cenário", "Nome", JOptionPane.INFORMATION_MESSAGE);
                if (nome != null) {
                    cenario.setNome(nome);
                } else {
                    return;
                }
            } else if (opcao == JOptionPane.CANCEL_OPTION) {
                return;
            }
        }
        FileFilter filter = new FileNameExtensionFilter("Cenário Isométrico", "isom");
        JFileChooser fc = new JFileChooser();
        fc.setFileFilter(filter);
        int option = fc.showSaveDialog(null);
        if (option == JFileChooser.APPROVE_OPTION) {
            File f = fc.getSelectedFile();
            String filePath = f.getPath();
            if (!filePath.toLowerCase().endsWith(".isom")) {
                f = new File(filePath + ".isom");
            }
            cenario.salvarCenario(f);

        }
    }

    /**
     * Abre janela para selecionar um novo tile para adicionar no tileset.
     */
    private void addTileSet() {
        JFileChooser fc = new JFileChooser();
        int option = fc.showOpenDialog(null);
        if (option == JFileChooser.APPROVE_OPTION) {
            File file = fc.getSelectedFile();
            if (!file.getName().contains(".ppm")) {
                JOptionPane.showMessageDialog(null, "Apenas é permitido selecionar tiles com extensão ppm!");
                return;
            }
            InputStream is = null;
            try {
                is = new FileInputStream(file);
            } catch (FileNotFoundException ex) {
                System.out.println("Erro");
            }
            PPM ppm = new PPM();
            try {
                ppm.loadPPM(is);
            } catch (IOException ex) {
                System.out.println("Erro");
            }
            Imagem img = ppm.getImagem();
            Tile t1 = new Tile(0, img);
            cenario.getTileSet().addTile(t1);
        }
    }

    /**
     * Desenha os tiles do tileset no rodapé da tela.
     * @param gl 
     */
    private void exibeTileSet(GL gl) {
        int x = 10;
        int y = 42;
        int i = 0;
        //Cabe 11 de largura
        for (Tile tile : cenario.getTileSet().tileset) {
            if (i == cenario.getTileSet().tileset.size()) {
                break;
            }

            if (i == 12) {
                x = 10;
                y = 10;
            }
            // Move the "drawing cursor" around
            gl.glRasterPos2i(x, y);
            x += Cenario.TILE_W;
            i++;
            // Insere o buffer de INT, com canal alpha e cada BYTE do INT para ARGB respectivamente
            gl.glDrawPixels(tile.getImagem().getLargura(), tile.getImagem().getAltura(), gl.GL_BGRA, gl.GL_UNSIGNED_BYTE, tile.getImagem().getPixels());
        }
    }

    /**
     * Rotina para desenhar o tilemap de acordo com as dimensões definidas.
     * Cada tile possui um ID, se for zero, move a imagem sem fundo Default.
     * Senão, pega a imagem referente no Tileset.
     * @param gl 
     */
    private void exibeDiamondMap(GL gl) {
        if (cenario.getIsoView() == null) {
            return;
        }
        int yInicial = 350;
        int xInicial = 500 - cenario.getAltura() * 32;
        Imagem imagem;

        for (int x = 0; x < cenario.getAltura(); x++) {

            for (int y = 0; y < cenario.getLargura(); y++) {
                int id = cenario.getIsoView().tileMap.getTileId(x, y);
                cenario.getIsoView().calcTilePosition(x, y);
                // Move the "drawing cursor" around
                gl.glRasterPos2i(cenario.getIsoView().x + xInicial, cenario.getIsoView().y + yInicial);
                Tile t1 = cenario.getTileSet().getTile(id);
                // Se não tem id para imagem
                if (id == 0 || t1 == null) {
                    // Limpa o Id da ocorrência
                    cenario.getIsoView().tileMap.setTileId(x, y, 0);
                    gl.glDrawPixels(imagemDefault.getLargura(), imagemDefault.getAltura(), gl.GL_BGRA, gl.GL_UNSIGNED_BYTE, imagemDefault.getPixels());

                } else {
                    imagem = t1.getImagem();
                    gl.glDrawPixels(imagem.getLargura(), imagem.getAltura(), gl.GL_BGRA, gl.GL_UNSIGNED_BYTE, imagem.getPixels());
                }

            }
        }
        if (cenario.getBoneco() != null) {
            cenario.getIsoView().calcTilePosition(cenario.getLinhaBoneco(), cenario.getColunaBoneco());
            // Move the "drawing cursor" around
            gl.glRasterPos2i(cenario.getIsoView().x + xInicial, cenario.getIsoView().y + yInicial);
            gl.glDrawPixels(cenario.getBoneco().getLargura(), cenario.getBoneco().getAltura(), gl.GL_BGRA, gl.GL_UNSIGNED_BYTE, cenario.getBoneco().getPixels());
        }
    }

    /**
     * Avalia se foi clicado em algum tile do Tileset e retorna o id deste
     * tile. Se não clicou em nenhum, retorna Zero. Também deleta o tile do 
     * tile set se estava na função de excluir.
     * @param gl
     * @return 
     */
    private int verificaCliqueTileSet(GL gl) {

        if (windowH - mousey > (42 + 32)) {
            return 0;
        }
        int ocorrenciaTile = (mousex - 10) / 64;

        if (windowH - mousey < 42) {
            ocorrenciaTile += 12;
        }
        if (cenario.getTileSet().tileset.size() > ocorrenciaTile) {
            int id = cenario.getTileSet().tileset.get(ocorrenciaTile).getId();

            Tile t1 = cenario.getTileSet().getTile(id);
            int x = mousex - ((ocorrenciaTile * 64) + 10);
            int y = windowH - mousey - 43;
            if (y < 0) {
                y += 32;
                x = mousex - (((ocorrenciaTile - 12) * 64) + 10);
            }
            int pixel = t1.getImagem().getARGB(x, y);
            if (pixel != Imagem.TRANSPARENTE) {

                if (deletarTile) {
                    cenario.getTileSet().removeTile(ocorrenciaTile);
                    deletarTile = false;
                    return 0;
                }
                return id;
            }
        }
        return 0;
    }

    /**
     * Avalia se o mouse clicou em algum tile do tileMap, permitindo alterar
     * o tile ou deletá-lo.
     */
    private void verificaCliqueTileMap() {

        int xInicial = mousex - (500 - cenario.getAltura() * 32);
        int yInicial = windowH - mousey - 350;

        cenario.getIsoView().mouseMap(xInicial, yInicial);
        if (cenario.getIsoView().linha >= 0) {
            ajustaPosicao(xInicial, yInicial);
        }
        int linha = cenario.getIsoView().linha;
        int coluna = cenario.getIsoView().coluna;
        if (linha == -1 || coluna == -1) {
            return;
        }
        if (deletarTile) {
            cenario.getIsoView().tileMap.setTileId(linha, coluna, 0);
            return;
        }
        if (tileId != 0) {
            cenario.getIsoView().tileMap.setTileId(linha, coluna, tileId);
            tileId = 0;
        }
    }

    /**
     * Identifica a posição do tile que foi clicado no tileset e cria uma 
     * cópia da imagem para realizar o movimento de dragandrop.
     * @param id 
     */
    public void criaImagemDragAndDrop(int id) {

        int x = 10;
        int y = 42;
        int i = 0;
        //Cabe 11 de largura
        for (Tile tile : cenario.getTileSet().tileset) {
            if (i == cenario.getTileSet().tileset.size()) {
                break;
            }
            if (i == 12) {
                x = 10;
                y = 10;
            }
            if (id == tile.getId()) {
                break;
            }
            x += Cenario.TILE_W;
        }
        xTileDragAndDrop = mousex - x;
        yTileDragAndDrop = (windowH - mousey) - y;
        imagemDragAndDrop = cenario.getTileSet().getTile(id).getImagem();
        tileId = id;

    }

    /**
     * Atualiza posição do mouse
     * @param e 
     */
    public void mouseDragged(MouseEvent e) {
        mousey = e.getY();
        mousex = e.getX();
    }

    /**
     * Rotina para desenhar o tile sob o mouse, causando efeito DragAndDrop.
     * @param gl 
     */
    private void desenhaTileDragAndDrop(GL gl) {
        int y = windowH - mousey - yTileDragAndDrop;
        int x = mousex - xTileDragAndDrop;

        System.out.println("DTDD x: " + x + " y " + y);
        // Move the "drawing cursor" around
        gl.glRasterPos2i(x, y);
        gl.glDrawPixels(imagemDragAndDrop.getLargura(), imagemDragAndDrop.getAltura(), gl.GL_BGRA, gl.GL_UNSIGNED_BYTE, imagemDragAndDrop.getPixels());
    }

    /**
     * Aceita janela para selecionar arquivo que irá compor o personagem da tela.
     * 
     */
    private void adicionaBoneco() {

        JFileChooser fc = new JFileChooser();
        int option = fc.showOpenDialog(null);
        if (option == JFileChooser.APPROVE_OPTION) {
            File file = fc.getSelectedFile();
            if (!file.getName().contains(".ppm")) {
                JOptionPane.showMessageDialog(null, "Apenas é permitido selecionar tiles com extensão ppm!");
                return;
            }
            InputStream is = null;
            try {
                is = new FileInputStream(file);
            } catch (FileNotFoundException ex) {
                System.out.println("Erro");
            }
            PPM ppm = new PPM();
            try {
                ppm.loadPPM(is);
            } catch (IOException ex) {
                System.out.println("Erro");
            }
            cenario.setBoneco(ppm.getImagem());
        }
    }

    /**
     * Verifica se ciclou em alguma tecla e soltou logo em seguida para dar
     * o movimento ao personagem adicionado ao diamond map.
     * Se clicou em uma tecla somente (up, down, left, right), vai realizar
     * o movimento ao soltar a tecla, mas se clicou em duas teclas ao mesmo
     * tempo, para fazer o movimento na diagonal, só vai andar com o personagem
     * quando soltar as duas teclas.
     */
    private void verificaMovimentoPersonagem() {
        if (cenario.getBoneco() == null) {
            return;
        }
        // Aqui verifica se clicou em algum botão mas não soltou ainda
        if ((!pressedTecDown && !pressedTecUp && !pressedTecLeft && !pressedTecRight) || (pressedTecDown && !releasedTecDown) || (pressedTecUp && !releasedTecUp) || (pressedTecLeft && !releasedTecLeft) || (pressedTecRight && !releasedTecRight)) {
            return;
        }
        cenario.getIsoView().linha = cenario.getLinhaBoneco();
        cenario.getIsoView().coluna = cenario.getColunaBoneco();
        
        // Avalia a tecla que foi pressiona e altera estado do personagem
        if (pressedTecDown && pressedTecRight) {
            cenario.getIsoView().tileWalking(TileMapViewInterface.SUDESTE);
            pressedTecDown = releasedTecDown = pressedTecRight = releasedTecRight = false;
        } 
        if (pressedTecDown && pressedTecLeft) {
            cenario.getIsoView().tileWalking(TileMapViewInterface.SUDOESTE);
            pressedTecDown = releasedTecDown = pressedTecLeft = releasedTecLeft = false;
        }
        if (pressedTecUp && pressedTecRight) {
            cenario.getIsoView().tileWalking(TileMapViewInterface.NORDESTE);
            pressedTecUp = releasedTecUp = pressedTecRight = releasedTecRight = false;
        }
        if (pressedTecUp && pressedTecLeft) {
            cenario.getIsoView().tileWalking(TileMapViewInterface.NOROESTE);
            pressedTecUp = releasedTecUp = pressedTecLeft = releasedTecLeft = false;
        }
        if (pressedTecUp) {
            cenario.getIsoView().tileWalking(TileMapViewInterface.NORTE);
            pressedTecUp = releasedTecUp = false;
        }
        if (pressedTecLeft) {
            cenario.getIsoView().tileWalking(TileMapViewInterface.OESTE);
            pressedTecLeft = pressedTecLeft = false;
        }
        if (pressedTecRight) {
            cenario.getIsoView().tileWalking(TileMapViewInterface.LESTE);
            pressedTecRight = releasedTecRight = false;
        }
        if (pressedTecDown) {
            cenario.getIsoView().tileWalking(TileMapViewInterface.SUL);
            pressedTecDown = releasedTecDown = false;
        }
        
        if (cenario.getIsoView().linha == -1) {
            return;
        }
        cenario.setLinhaBoneco(cenario.getIsoView().linha);
        cenario.setColunaBoneco(cenario.getIsoView().coluna);
    }
    public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {
    }
    public void mouseMoved(MouseEvent e) {
    }
}
